
#region license
/// Copyright (c) 2007 Rodrigo B. de Oliveira, Jb Evain and the
/// individuals listed on the ChangeLog entries.
/// 
/// Permission is hereby granted, free of charge, to any person obtaining
/// a copy of this software and associated documentation files (the
/// "Software"), to deal in the Software without restriction, including
/// without limitation the rights to use, copy, modify, merge, publish,
/// distribute, sublicense, and/or sell copies of the Software, and to
/// permit persons to whom the Software is furnished to do so, subject to
/// the following conditions:
/// 
/// The above copyright notice and this permission notice shall be
/// included in all copies or substantial portions of the Software.
/// 
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
/// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
/// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
/// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
/// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
/// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
/// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#endregion
//
// DO NOT EDIT THIS FILE!
//
// This file was generated automatically by astgen.boo.
//


namespace Milo.Ast
{
	using System;
	
	public partial class DepthFirstTransformer : IAstVisitor
	{

		public virtual void OnCompileUnit(Milo.Ast.CompileUnit node)
		{	
			if (EnterCompileUnit(node))
			{
				Visit(node.Modules);

				LeaveCompileUnit(node);
			}
		}

		public virtual bool EnterCompileUnit(Milo.Ast.CompileUnit node)
		{
			return true;
		}
		
		public virtual void LeaveCompileUnit(Milo.Ast.CompileUnit node)
		{
		}

		public virtual void OnExplicitMemberInfo(Milo.Ast.ExplicitMemberInfo node)
		{	
			if (EnterExplicitMemberInfo(node))
			{
				SimpleTypeReference currentInterfaceTypeValue = node.InterfaceType;
				if (null != currentInterfaceTypeValue)
				{			
					SimpleTypeReference newValue = (SimpleTypeReference)VisitNode(currentInterfaceTypeValue);
					if (!object.ReferenceEquals(newValue, currentInterfaceTypeValue))
					{
						node.InterfaceType = newValue;
					}
				}

				LeaveExplicitMemberInfo(node);
			}
		}

		public virtual bool EnterExplicitMemberInfo(Milo.Ast.ExplicitMemberInfo node)
		{
			return true;
		}
		
		public virtual void LeaveExplicitMemberInfo(Milo.Ast.ExplicitMemberInfo node)
		{
		}

		public virtual void OnSimpleTypeReference(Milo.Ast.SimpleTypeReference node)
		{	
		}

		public virtual void OnArrayTypeReference(Milo.Ast.ArrayTypeReference node)
		{	
			if (EnterArrayTypeReference(node))
			{
				TypeReference currentElementTypeValue = node.ElementType;
				if (null != currentElementTypeValue)
				{			
					TypeReference newValue = (TypeReference)VisitNode(currentElementTypeValue);
					if (!object.ReferenceEquals(newValue, currentElementTypeValue))
					{
						node.ElementType = newValue;
					}
				}
				IntegerLiteralExpression currentRankValue = node.Rank;
				if (null != currentRankValue)
				{			
					IntegerLiteralExpression newValue = (IntegerLiteralExpression)VisitNode(currentRankValue);
					if (!object.ReferenceEquals(newValue, currentRankValue))
					{
						node.Rank = newValue;
					}
				}

				LeaveArrayTypeReference(node);
			}
		}

		public virtual bool EnterArrayTypeReference(Milo.Ast.ArrayTypeReference node)
		{
			return true;
		}
		
		public virtual void LeaveArrayTypeReference(Milo.Ast.ArrayTypeReference node)
		{
		}

		public virtual void OnCallableTypeReference(Milo.Ast.CallableTypeReference node)
		{	
			if (EnterCallableTypeReference(node))
			{
				Visit(node.Parameters);
				TypeReference currentReturnTypeValue = node.ReturnType;
				if (null != currentReturnTypeValue)
				{			
					TypeReference newValue = (TypeReference)VisitNode(currentReturnTypeValue);
					if (!object.ReferenceEquals(newValue, currentReturnTypeValue))
					{
						node.ReturnType = newValue;
					}
				}

				LeaveCallableTypeReference(node);
			}
		}

		public virtual bool EnterCallableTypeReference(Milo.Ast.CallableTypeReference node)
		{
			return true;
		}
		
		public virtual void LeaveCallableTypeReference(Milo.Ast.CallableTypeReference node)
		{
		}

		public virtual void OnGenericTypeReference(Milo.Ast.GenericTypeReference node)
		{	
			if (EnterGenericTypeReference(node))
			{
				Visit(node.GenericArguments);

				LeaveGenericTypeReference(node);
			}
		}

		public virtual bool EnterGenericTypeReference(Milo.Ast.GenericTypeReference node)
		{
			return true;
		}
		
		public virtual void LeaveGenericTypeReference(Milo.Ast.GenericTypeReference node)
		{
		}

		public virtual void OnGenericTypeDefinitionReference(Milo.Ast.GenericTypeDefinitionReference node)
		{	
		}

		public virtual void OnCallableDefinition(Milo.Ast.CallableDefinition node)
		{	
			if (EnterCallableDefinition(node))
			{
				Visit(node.Attributes);
				Visit(node.Parameters);
				Visit(node.GenericParameters);
				TypeReference currentReturnTypeValue = node.ReturnType;
				if (null != currentReturnTypeValue)
				{			
					TypeReference newValue = (TypeReference)VisitNode(currentReturnTypeValue);
					if (!object.ReferenceEquals(newValue, currentReturnTypeValue))
					{
						node.ReturnType = newValue;
					}
				}
				Visit(node.ReturnTypeAttributes);

				LeaveCallableDefinition(node);
			}
		}

		public virtual bool EnterCallableDefinition(Milo.Ast.CallableDefinition node)
		{
			return true;
		}
		
		public virtual void LeaveCallableDefinition(Milo.Ast.CallableDefinition node)
		{
		}

		public virtual void OnNamespaceDeclaration(Milo.Ast.NamespaceDeclaration node)
		{	
		}

		public virtual void OnImport(Milo.Ast.Import node)
		{	
			if (EnterImport(node))
			{
				ReferenceExpression currentAssemblyReferenceValue = node.AssemblyReference;
				if (null != currentAssemblyReferenceValue)
				{			
					ReferenceExpression newValue = (ReferenceExpression)VisitNode(currentAssemblyReferenceValue);
					if (!object.ReferenceEquals(newValue, currentAssemblyReferenceValue))
					{
						node.AssemblyReference = newValue;
					}
				}
				ReferenceExpression currentAliasValue = node.Alias;
				if (null != currentAliasValue)
				{			
					ReferenceExpression newValue = (ReferenceExpression)VisitNode(currentAliasValue);
					if (!object.ReferenceEquals(newValue, currentAliasValue))
					{
						node.Alias = newValue;
					}
				}

				LeaveImport(node);
			}
		}

		public virtual bool EnterImport(Milo.Ast.Import node)
		{
			return true;
		}
		
		public virtual void LeaveImport(Milo.Ast.Import node)
		{
		}

		public virtual void OnModule(Milo.Ast.Module node)
		{	
			if (EnterModule(node))
			{
				Visit(node.Attributes);
				Visit(node.Members);
				Visit(node.BaseTypes);
				NamespaceDeclaration currentNamespaceValue = node.Namespace;
				if (null != currentNamespaceValue)
				{			
					NamespaceDeclaration newValue = (NamespaceDeclaration)VisitNode(currentNamespaceValue);
					if (!object.ReferenceEquals(newValue, currentNamespaceValue))
					{
						node.Namespace = newValue;
					}
				}
				Visit(node.Imports);
				Block currentGlobalsValue = node.Globals;
				if (null != currentGlobalsValue)
				{			
					Block newValue = (Block)VisitNode(currentGlobalsValue);
					if (!object.ReferenceEquals(newValue, currentGlobalsValue))
					{
						node.Globals = newValue;
					}
				}
				Visit(node.AssemblyAttributes);

				LeaveModule(node);
			}
		}

		public virtual bool EnterModule(Milo.Ast.Module node)
		{
			return true;
		}
		
		public virtual void LeaveModule(Milo.Ast.Module node)
		{
		}

		public virtual void OnClassDefinition(Milo.Ast.ClassDefinition node)
		{	
			if (EnterClassDefinition(node))
			{
				Visit(node.Attributes);
				Visit(node.Members);
				Visit(node.BaseTypes);

				LeaveClassDefinition(node);
			}
		}

		public virtual bool EnterClassDefinition(Milo.Ast.ClassDefinition node)
		{
			return true;
		}
		
		public virtual void LeaveClassDefinition(Milo.Ast.ClassDefinition node)
		{
		}

		public virtual void OnStructDefinition(Milo.Ast.StructDefinition node)
		{	
			if (EnterStructDefinition(node))
			{
				Visit(node.Attributes);
				Visit(node.Members);
				Visit(node.BaseTypes);

				LeaveStructDefinition(node);
			}
		}

		public virtual bool EnterStructDefinition(Milo.Ast.StructDefinition node)
		{
			return true;
		}
		
		public virtual void LeaveStructDefinition(Milo.Ast.StructDefinition node)
		{
		}

		public virtual void OnInterfaceDefinition(Milo.Ast.InterfaceDefinition node)
		{	
			if (EnterInterfaceDefinition(node))
			{
				Visit(node.Attributes);
				Visit(node.Members);
				Visit(node.BaseTypes);

				LeaveInterfaceDefinition(node);
			}
		}

		public virtual bool EnterInterfaceDefinition(Milo.Ast.InterfaceDefinition node)
		{
			return true;
		}
		
		public virtual void LeaveInterfaceDefinition(Milo.Ast.InterfaceDefinition node)
		{
		}

		public virtual void OnEnumDefinition(Milo.Ast.EnumDefinition node)
		{	
			if (EnterEnumDefinition(node))
			{
				Visit(node.Attributes);
				Visit(node.Members);
				Visit(node.BaseTypes);

				LeaveEnumDefinition(node);
			}
		}

		public virtual bool EnterEnumDefinition(Milo.Ast.EnumDefinition node)
		{
			return true;
		}
		
		public virtual void LeaveEnumDefinition(Milo.Ast.EnumDefinition node)
		{
		}

		public virtual void OnEnumMember(Milo.Ast.EnumMember node)
		{	
			if (EnterEnumMember(node))
			{
				Visit(node.Attributes);
				IntegerLiteralExpression currentInitializerValue = node.Initializer;
				if (null != currentInitializerValue)
				{			
					IntegerLiteralExpression newValue = (IntegerLiteralExpression)VisitNode(currentInitializerValue);
					if (!object.ReferenceEquals(newValue, currentInitializerValue))
					{
						node.Initializer = newValue;
					}
				}

				LeaveEnumMember(node);
			}
		}

		public virtual bool EnterEnumMember(Milo.Ast.EnumMember node)
		{
			return true;
		}
		
		public virtual void LeaveEnumMember(Milo.Ast.EnumMember node)
		{
		}

		public virtual void OnField(Milo.Ast.Field node)
		{	
			if (EnterField(node))
			{
				Visit(node.Attributes);
				TypeReference currentTypeValue = node.Type;
				if (null != currentTypeValue)
				{			
					TypeReference newValue = (TypeReference)VisitNode(currentTypeValue);
					if (!object.ReferenceEquals(newValue, currentTypeValue))
					{
						node.Type = newValue;
					}
				}
				Expression currentInitializerValue = node.Initializer;
				if (null != currentInitializerValue)
				{			
					Expression newValue = (Expression)VisitNode(currentInitializerValue);
					if (!object.ReferenceEquals(newValue, currentInitializerValue))
					{
						node.Initializer = newValue;
					}
				}

				LeaveField(node);
			}
		}

		public virtual bool EnterField(Milo.Ast.Field node)
		{
			return true;
		}
		
		public virtual void LeaveField(Milo.Ast.Field node)
		{
		}

		public virtual void OnProperty(Milo.Ast.Property node)
		{	
			if (EnterProperty(node))
			{
				Visit(node.Attributes);
				Visit(node.Parameters);
				Method currentGetterValue = node.Getter;
				if (null != currentGetterValue)
				{			
					Method newValue = (Method)VisitNode(currentGetterValue);
					if (!object.ReferenceEquals(newValue, currentGetterValue))
					{
						node.Getter = newValue;
					}
				}
				Method currentSetterValue = node.Setter;
				if (null != currentSetterValue)
				{			
					Method newValue = (Method)VisitNode(currentSetterValue);
					if (!object.ReferenceEquals(newValue, currentSetterValue))
					{
						node.Setter = newValue;
					}
				}
				TypeReference currentTypeValue = node.Type;
				if (null != currentTypeValue)
				{			
					TypeReference newValue = (TypeReference)VisitNode(currentTypeValue);
					if (!object.ReferenceEquals(newValue, currentTypeValue))
					{
						node.Type = newValue;
					}
				}
				ExplicitMemberInfo currentExplicitInfoValue = node.ExplicitInfo;
				if (null != currentExplicitInfoValue)
				{			
					ExplicitMemberInfo newValue = (ExplicitMemberInfo)VisitNode(currentExplicitInfoValue);
					if (!object.ReferenceEquals(newValue, currentExplicitInfoValue))
					{
						node.ExplicitInfo = newValue;
					}
				}

				LeaveProperty(node);
			}
		}

		public virtual bool EnterProperty(Milo.Ast.Property node)
		{
			return true;
		}
		
		public virtual void LeaveProperty(Milo.Ast.Property node)
		{
		}

		public virtual void OnEvent(Milo.Ast.Event node)
		{	
			if (EnterEvent(node))
			{
				Visit(node.Attributes);
				Method currentAddValue = node.Add;
				if (null != currentAddValue)
				{			
					Method newValue = (Method)VisitNode(currentAddValue);
					if (!object.ReferenceEquals(newValue, currentAddValue))
					{
						node.Add = newValue;
					}
				}
				Method currentRemoveValue = node.Remove;
				if (null != currentRemoveValue)
				{			
					Method newValue = (Method)VisitNode(currentRemoveValue);
					if (!object.ReferenceEquals(newValue, currentRemoveValue))
					{
						node.Remove = newValue;
					}
				}
				Method currentRaiseValue = node.Raise;
				if (null != currentRaiseValue)
				{			
					Method newValue = (Method)VisitNode(currentRaiseValue);
					if (!object.ReferenceEquals(newValue, currentRaiseValue))
					{
						node.Raise = newValue;
					}
				}
				TypeReference currentTypeValue = node.Type;
				if (null != currentTypeValue)
				{			
					TypeReference newValue = (TypeReference)VisitNode(currentTypeValue);
					if (!object.ReferenceEquals(newValue, currentTypeValue))
					{
						node.Type = newValue;
					}
				}

				LeaveEvent(node);
			}
		}

		public virtual bool EnterEvent(Milo.Ast.Event node)
		{
			return true;
		}
		
		public virtual void LeaveEvent(Milo.Ast.Event node)
		{
		}

		public virtual void OnLocal(Milo.Ast.Local node)
		{	
		}

		public virtual void OnBlockExpression(Milo.Ast.BlockExpression node)
		{	
			if (EnterBlockExpression(node))
			{
				Visit(node.Parameters);
				TypeReference currentReturnTypeValue = node.ReturnType;
				if (null != currentReturnTypeValue)
				{			
					TypeReference newValue = (TypeReference)VisitNode(currentReturnTypeValue);
					if (!object.ReferenceEquals(newValue, currentReturnTypeValue))
					{
						node.ReturnType = newValue;
					}
				}
				Block currentBodyValue = node.Body;
				if (null != currentBodyValue)
				{			
					Block newValue = (Block)VisitNode(currentBodyValue);
					if (!object.ReferenceEquals(newValue, currentBodyValue))
					{
						node.Body = newValue;
					}
				}

				LeaveBlockExpression(node);
			}
		}

		public virtual bool EnterBlockExpression(Milo.Ast.BlockExpression node)
		{
			return true;
		}
		
		public virtual void LeaveBlockExpression(Milo.Ast.BlockExpression node)
		{
		}

		public virtual void OnMethod(Milo.Ast.Method node)
		{	
			if (EnterMethod(node))
			{
				Visit(node.Attributes);
				Visit(node.Parameters);
				Visit(node.GenericParameters);
				TypeReference currentReturnTypeValue = node.ReturnType;
				if (null != currentReturnTypeValue)
				{			
					TypeReference newValue = (TypeReference)VisitNode(currentReturnTypeValue);
					if (!object.ReferenceEquals(newValue, currentReturnTypeValue))
					{
						node.ReturnType = newValue;
					}
				}
				Visit(node.ReturnTypeAttributes);
				Block currentBodyValue = node.Body;
				if (null != currentBodyValue)
				{			
					Block newValue = (Block)VisitNode(currentBodyValue);
					if (!object.ReferenceEquals(newValue, currentBodyValue))
					{
						node.Body = newValue;
					}
				}
				Visit(node.Locals);
				ExplicitMemberInfo currentExplicitInfoValue = node.ExplicitInfo;
				if (null != currentExplicitInfoValue)
				{			
					ExplicitMemberInfo newValue = (ExplicitMemberInfo)VisitNode(currentExplicitInfoValue);
					if (!object.ReferenceEquals(newValue, currentExplicitInfoValue))
					{
						node.ExplicitInfo = newValue;
					}
				}

				LeaveMethod(node);
			}
		}

		public virtual bool EnterMethod(Milo.Ast.Method node)
		{
			return true;
		}
		
		public virtual void LeaveMethod(Milo.Ast.Method node)
		{
		}

		public virtual void OnConstructor(Milo.Ast.Constructor node)
		{	
			if (EnterConstructor(node))
			{
				Visit(node.Attributes);
				Visit(node.Parameters);
				Visit(node.GenericParameters);
				TypeReference currentReturnTypeValue = node.ReturnType;
				if (null != currentReturnTypeValue)
				{			
					TypeReference newValue = (TypeReference)VisitNode(currentReturnTypeValue);
					if (!object.ReferenceEquals(newValue, currentReturnTypeValue))
					{
						node.ReturnType = newValue;
					}
				}
				Visit(node.ReturnTypeAttributes);
				Block currentBodyValue = node.Body;
				if (null != currentBodyValue)
				{			
					Block newValue = (Block)VisitNode(currentBodyValue);
					if (!object.ReferenceEquals(newValue, currentBodyValue))
					{
						node.Body = newValue;
					}
				}
				Visit(node.Locals);
				ExplicitMemberInfo currentExplicitInfoValue = node.ExplicitInfo;
				if (null != currentExplicitInfoValue)
				{			
					ExplicitMemberInfo newValue = (ExplicitMemberInfo)VisitNode(currentExplicitInfoValue);
					if (!object.ReferenceEquals(newValue, currentExplicitInfoValue))
					{
						node.ExplicitInfo = newValue;
					}
				}

				LeaveConstructor(node);
			}
		}

		public virtual bool EnterConstructor(Milo.Ast.Constructor node)
		{
			return true;
		}
		
		public virtual void LeaveConstructor(Milo.Ast.Constructor node)
		{
		}

		public virtual void OnDestructor(Milo.Ast.Destructor node)
		{	
			if (EnterDestructor(node))
			{
				Visit(node.Attributes);
				Visit(node.Parameters);
				Visit(node.GenericParameters);
				TypeReference currentReturnTypeValue = node.ReturnType;
				if (null != currentReturnTypeValue)
				{			
					TypeReference newValue = (TypeReference)VisitNode(currentReturnTypeValue);
					if (!object.ReferenceEquals(newValue, currentReturnTypeValue))
					{
						node.ReturnType = newValue;
					}
				}
				Visit(node.ReturnTypeAttributes);
				Block currentBodyValue = node.Body;
				if (null != currentBodyValue)
				{			
					Block newValue = (Block)VisitNode(currentBodyValue);
					if (!object.ReferenceEquals(newValue, currentBodyValue))
					{
						node.Body = newValue;
					}
				}
				Visit(node.Locals);
				ExplicitMemberInfo currentExplicitInfoValue = node.ExplicitInfo;
				if (null != currentExplicitInfoValue)
				{			
					ExplicitMemberInfo newValue = (ExplicitMemberInfo)VisitNode(currentExplicitInfoValue);
					if (!object.ReferenceEquals(newValue, currentExplicitInfoValue))
					{
						node.ExplicitInfo = newValue;
					}
				}

				LeaveDestructor(node);
			}
		}

		public virtual bool EnterDestructor(Milo.Ast.Destructor node)
		{
			return true;
		}
		
		public virtual void LeaveDestructor(Milo.Ast.Destructor node)
		{
		}

		public virtual void OnParameterDeclaration(Milo.Ast.ParameterDeclaration node)
		{	
			if (EnterParameterDeclaration(node))
			{
				TypeReference currentTypeValue = node.Type;
				if (null != currentTypeValue)
				{			
					TypeReference newValue = (TypeReference)VisitNode(currentTypeValue);
					if (!object.ReferenceEquals(newValue, currentTypeValue))
					{
						node.Type = newValue;
					}
				}
				Visit(node.Attributes);

				LeaveParameterDeclaration(node);
			}
		}

		public virtual bool EnterParameterDeclaration(Milo.Ast.ParameterDeclaration node)
		{
			return true;
		}
		
		public virtual void LeaveParameterDeclaration(Milo.Ast.ParameterDeclaration node)
		{
		}

		public virtual void OnGenericParameterDeclaration(Milo.Ast.GenericParameterDeclaration node)
		{	
		}

		public virtual void OnDeclaration(Milo.Ast.Declaration node)
		{	
			if (EnterDeclaration(node))
			{
				TypeReference currentTypeValue = node.Type;
				if (null != currentTypeValue)
				{			
					TypeReference newValue = (TypeReference)VisitNode(currentTypeValue);
					if (!object.ReferenceEquals(newValue, currentTypeValue))
					{
						node.Type = newValue;
					}
				}

				LeaveDeclaration(node);
			}
		}

		public virtual bool EnterDeclaration(Milo.Ast.Declaration node)
		{
			return true;
		}
		
		public virtual void LeaveDeclaration(Milo.Ast.Declaration node)
		{
		}

		public virtual void OnAttribute(Milo.Ast.Attribute node)
		{	
			if (EnterAttribute(node))
			{
				Visit(node.Arguments);
				Visit(node.NamedArguments);

				LeaveAttribute(node);
			}
		}

		public virtual bool EnterAttribute(Milo.Ast.Attribute node)
		{
			return true;
		}
		
		public virtual void LeaveAttribute(Milo.Ast.Attribute node)
		{
		}

		public virtual void OnStatementModifier(Milo.Ast.StatementModifier node)
		{	
			if (EnterStatementModifier(node))
			{
				Expression currentConditionValue = node.Condition;
				if (null != currentConditionValue)
				{			
					Expression newValue = (Expression)VisitNode(currentConditionValue);
					if (!object.ReferenceEquals(newValue, currentConditionValue))
					{
						node.Condition = newValue;
					}
				}

				LeaveStatementModifier(node);
			}
		}

		public virtual bool EnterStatementModifier(Milo.Ast.StatementModifier node)
		{
			return true;
		}
		
		public virtual void LeaveStatementModifier(Milo.Ast.StatementModifier node)
		{
		}

		public virtual void OnGotoStatement(Milo.Ast.GotoStatement node)
		{	
			if (EnterGotoStatement(node))
			{
				StatementModifier currentModifierValue = node.Modifier;
				if (null != currentModifierValue)
				{			
					StatementModifier newValue = (StatementModifier)VisitNode(currentModifierValue);
					if (!object.ReferenceEquals(newValue, currentModifierValue))
					{
						node.Modifier = newValue;
					}
				}
				ReferenceExpression currentLabelValue = node.Label;
				if (null != currentLabelValue)
				{			
					ReferenceExpression newValue = (ReferenceExpression)VisitNode(currentLabelValue);
					if (!object.ReferenceEquals(newValue, currentLabelValue))
					{
						node.Label = newValue;
					}
				}

				LeaveGotoStatement(node);
			}
		}

		public virtual bool EnterGotoStatement(Milo.Ast.GotoStatement node)
		{
			return true;
		}
		
		public virtual void LeaveGotoStatement(Milo.Ast.GotoStatement node)
		{
		}

		public virtual void OnLabelStatement(Milo.Ast.LabelStatement node)
		{	
			if (EnterLabelStatement(node))
			{
				StatementModifier currentModifierValue = node.Modifier;
				if (null != currentModifierValue)
				{			
					StatementModifier newValue = (StatementModifier)VisitNode(currentModifierValue);
					if (!object.ReferenceEquals(newValue, currentModifierValue))
					{
						node.Modifier = newValue;
					}
				}

				LeaveLabelStatement(node);
			}
		}

		public virtual bool EnterLabelStatement(Milo.Ast.LabelStatement node)
		{
			return true;
		}
		
		public virtual void LeaveLabelStatement(Milo.Ast.LabelStatement node)
		{
		}

		public virtual void OnBlock(Milo.Ast.Block node)
		{	
			if (EnterBlock(node))
			{
				StatementModifier currentModifierValue = node.Modifier;
				if (null != currentModifierValue)
				{			
					StatementModifier newValue = (StatementModifier)VisitNode(currentModifierValue);
					if (!object.ReferenceEquals(newValue, currentModifierValue))
					{
						node.Modifier = newValue;
					}
				}
				Visit(node.Statements);

				LeaveBlock(node);
			}
		}

		public virtual bool EnterBlock(Milo.Ast.Block node)
		{
			return true;
		}
		
		public virtual void LeaveBlock(Milo.Ast.Block node)
		{
		}

		public virtual void OnDeclarationStatement(Milo.Ast.DeclarationStatement node)
		{	
			if (EnterDeclarationStatement(node))
			{
				StatementModifier currentModifierValue = node.Modifier;
				if (null != currentModifierValue)
				{			
					StatementModifier newValue = (StatementModifier)VisitNode(currentModifierValue);
					if (!object.ReferenceEquals(newValue, currentModifierValue))
					{
						node.Modifier = newValue;
					}
				}
				Declaration currentDeclarationValue = node.Declaration;
				if (null != currentDeclarationValue)
				{			
					Declaration newValue = (Declaration)VisitNode(currentDeclarationValue);
					if (!object.ReferenceEquals(newValue, currentDeclarationValue))
					{
						node.Declaration = newValue;
					}
				}
				Expression currentInitializerValue = node.Initializer;
				if (null != currentInitializerValue)
				{			
					Expression newValue = (Expression)VisitNode(currentInitializerValue);
					if (!object.ReferenceEquals(newValue, currentInitializerValue))
					{
						node.Initializer = newValue;
					}
				}

				LeaveDeclarationStatement(node);
			}
		}

		public virtual bool EnterDeclarationStatement(Milo.Ast.DeclarationStatement node)
		{
			return true;
		}
		
		public virtual void LeaveDeclarationStatement(Milo.Ast.DeclarationStatement node)
		{
		}

		public virtual void OnMacroStatement(Milo.Ast.MacroStatement node)
		{	
			if (EnterMacroStatement(node))
			{
				StatementModifier currentModifierValue = node.Modifier;
				if (null != currentModifierValue)
				{			
					StatementModifier newValue = (StatementModifier)VisitNode(currentModifierValue);
					if (!object.ReferenceEquals(newValue, currentModifierValue))
					{
						node.Modifier = newValue;
					}
				}
				Visit(node.Arguments);
				Block currentBlockValue = node.Block;
				if (null != currentBlockValue)
				{			
					Block newValue = (Block)VisitNode(currentBlockValue);
					if (!object.ReferenceEquals(newValue, currentBlockValue))
					{
						node.Block = newValue;
					}
				}

				LeaveMacroStatement(node);
			}
		}

		public virtual bool EnterMacroStatement(Milo.Ast.MacroStatement node)
		{
			return true;
		}
		
		public virtual void LeaveMacroStatement(Milo.Ast.MacroStatement node)
		{
		}

		public virtual void OnTryStatement(Milo.Ast.TryStatement node)
		{	
			if (EnterTryStatement(node))
			{
				StatementModifier currentModifierValue = node.Modifier;
				if (null != currentModifierValue)
				{			
					StatementModifier newValue = (StatementModifier)VisitNode(currentModifierValue);
					if (!object.ReferenceEquals(newValue, currentModifierValue))
					{
						node.Modifier = newValue;
					}
				}
				Block currentProtectedBlockValue = node.ProtectedBlock;
				if (null != currentProtectedBlockValue)
				{			
					Block newValue = (Block)VisitNode(currentProtectedBlockValue);
					if (!object.ReferenceEquals(newValue, currentProtectedBlockValue))
					{
						node.ProtectedBlock = newValue;
					}
				}
				Visit(node.ExceptionHandlers);
				Block currentEnsureBlockValue = node.EnsureBlock;
				if (null != currentEnsureBlockValue)
				{			
					Block newValue = (Block)VisitNode(currentEnsureBlockValue);
					if (!object.ReferenceEquals(newValue, currentEnsureBlockValue))
					{
						node.EnsureBlock = newValue;
					}
				}

				LeaveTryStatement(node);
			}
		}

		public virtual bool EnterTryStatement(Milo.Ast.TryStatement node)
		{
			return true;
		}
		
		public virtual void LeaveTryStatement(Milo.Ast.TryStatement node)
		{
		}

		public virtual void OnExceptionHandler(Milo.Ast.ExceptionHandler node)
		{	
			if (EnterExceptionHandler(node))
			{
				Declaration currentDeclarationValue = node.Declaration;
				if (null != currentDeclarationValue)
				{			
					Declaration newValue = (Declaration)VisitNode(currentDeclarationValue);
					if (!object.ReferenceEquals(newValue, currentDeclarationValue))
					{
						node.Declaration = newValue;
					}
				}
				Block currentBlockValue = node.Block;
				if (null != currentBlockValue)
				{			
					Block newValue = (Block)VisitNode(currentBlockValue);
					if (!object.ReferenceEquals(newValue, currentBlockValue))
					{
						node.Block = newValue;
					}
				}

				LeaveExceptionHandler(node);
			}
		}

		public virtual bool EnterExceptionHandler(Milo.Ast.ExceptionHandler node)
		{
			return true;
		}
		
		public virtual void LeaveExceptionHandler(Milo.Ast.ExceptionHandler node)
		{
		}

		public virtual void OnIfStatement(Milo.Ast.IfStatement node)
		{	
			if (EnterIfStatement(node))
			{
				StatementModifier currentModifierValue = node.Modifier;
				if (null != currentModifierValue)
				{			
					StatementModifier newValue = (StatementModifier)VisitNode(currentModifierValue);
					if (!object.ReferenceEquals(newValue, currentModifierValue))
					{
						node.Modifier = newValue;
					}
				}
				Expression currentConditionValue = node.Condition;
				if (null != currentConditionValue)
				{			
					Expression newValue = (Expression)VisitNode(currentConditionValue);
					if (!object.ReferenceEquals(newValue, currentConditionValue))
					{
						node.Condition = newValue;
					}
				}
				Block currentTrueBlockValue = node.TrueBlock;
				if (null != currentTrueBlockValue)
				{			
					Block newValue = (Block)VisitNode(currentTrueBlockValue);
					if (!object.ReferenceEquals(newValue, currentTrueBlockValue))
					{
						node.TrueBlock = newValue;
					}
				}
				Block currentFalseBlockValue = node.FalseBlock;
				if (null != currentFalseBlockValue)
				{			
					Block newValue = (Block)VisitNode(currentFalseBlockValue);
					if (!object.ReferenceEquals(newValue, currentFalseBlockValue))
					{
						node.FalseBlock = newValue;
					}
				}

				LeaveIfStatement(node);
			}
		}

		public virtual bool EnterIfStatement(Milo.Ast.IfStatement node)
		{
			return true;
		}
		
		public virtual void LeaveIfStatement(Milo.Ast.IfStatement node)
		{
		}

		public virtual void OnUnlessStatement(Milo.Ast.UnlessStatement node)
		{	
			if (EnterUnlessStatement(node))
			{
				StatementModifier currentModifierValue = node.Modifier;
				if (null != currentModifierValue)
				{			
					StatementModifier newValue = (StatementModifier)VisitNode(currentModifierValue);
					if (!object.ReferenceEquals(newValue, currentModifierValue))
					{
						node.Modifier = newValue;
					}
				}
				Expression currentConditionValue = node.Condition;
				if (null != currentConditionValue)
				{			
					Expression newValue = (Expression)VisitNode(currentConditionValue);
					if (!object.ReferenceEquals(newValue, currentConditionValue))
					{
						node.Condition = newValue;
					}
				}
				Block currentBlockValue = node.Block;
				if (null != currentBlockValue)
				{			
					Block newValue = (Block)VisitNode(currentBlockValue);
					if (!object.ReferenceEquals(newValue, currentBlockValue))
					{
						node.Block = newValue;
					}
				}

				LeaveUnlessStatement(node);
			}
		}

		public virtual bool EnterUnlessStatement(Milo.Ast.UnlessStatement node)
		{
			return true;
		}
		
		public virtual void LeaveUnlessStatement(Milo.Ast.UnlessStatement node)
		{
		}

		public virtual void OnForStatement(Milo.Ast.ForStatement node)
		{	
			if (EnterForStatement(node))
			{
				StatementModifier currentModifierValue = node.Modifier;
				if (null != currentModifierValue)
				{			
					StatementModifier newValue = (StatementModifier)VisitNode(currentModifierValue);
					if (!object.ReferenceEquals(newValue, currentModifierValue))
					{
						node.Modifier = newValue;
					}
				}
				Visit(node.Declarations);
				Expression currentIteratorValue = node.Iterator;
				if (null != currentIteratorValue)
				{			
					Expression newValue = (Expression)VisitNode(currentIteratorValue);
					if (!object.ReferenceEquals(newValue, currentIteratorValue))
					{
						node.Iterator = newValue;
					}
				}
				Block currentBlockValue = node.Block;
				if (null != currentBlockValue)
				{			
					Block newValue = (Block)VisitNode(currentBlockValue);
					if (!object.ReferenceEquals(newValue, currentBlockValue))
					{
						node.Block = newValue;
					}
				}

				LeaveForStatement(node);
			}
		}

		public virtual bool EnterForStatement(Milo.Ast.ForStatement node)
		{
			return true;
		}
		
		public virtual void LeaveForStatement(Milo.Ast.ForStatement node)
		{
		}

		public virtual void OnWhileStatement(Milo.Ast.WhileStatement node)
		{	
			if (EnterWhileStatement(node))
			{
				StatementModifier currentModifierValue = node.Modifier;
				if (null != currentModifierValue)
				{			
					StatementModifier newValue = (StatementModifier)VisitNode(currentModifierValue);
					if (!object.ReferenceEquals(newValue, currentModifierValue))
					{
						node.Modifier = newValue;
					}
				}
				Expression currentConditionValue = node.Condition;
				if (null != currentConditionValue)
				{			
					Expression newValue = (Expression)VisitNode(currentConditionValue);
					if (!object.ReferenceEquals(newValue, currentConditionValue))
					{
						node.Condition = newValue;
					}
				}
				Block currentBlockValue = node.Block;
				if (null != currentBlockValue)
				{			
					Block newValue = (Block)VisitNode(currentBlockValue);
					if (!object.ReferenceEquals(newValue, currentBlockValue))
					{
						node.Block = newValue;
					}
				}

				LeaveWhileStatement(node);
			}
		}

		public virtual bool EnterWhileStatement(Milo.Ast.WhileStatement node)
		{
			return true;
		}
		
		public virtual void LeaveWhileStatement(Milo.Ast.WhileStatement node)
		{
		}

		public virtual void OnBreakStatement(Milo.Ast.BreakStatement node)
		{	
			if (EnterBreakStatement(node))
			{
				StatementModifier currentModifierValue = node.Modifier;
				if (null != currentModifierValue)
				{			
					StatementModifier newValue = (StatementModifier)VisitNode(currentModifierValue);
					if (!object.ReferenceEquals(newValue, currentModifierValue))
					{
						node.Modifier = newValue;
					}
				}

				LeaveBreakStatement(node);
			}
		}

		public virtual bool EnterBreakStatement(Milo.Ast.BreakStatement node)
		{
			return true;
		}
		
		public virtual void LeaveBreakStatement(Milo.Ast.BreakStatement node)
		{
		}

		public virtual void OnContinueStatement(Milo.Ast.ContinueStatement node)
		{	
			if (EnterContinueStatement(node))
			{
				StatementModifier currentModifierValue = node.Modifier;
				if (null != currentModifierValue)
				{			
					StatementModifier newValue = (StatementModifier)VisitNode(currentModifierValue);
					if (!object.ReferenceEquals(newValue, currentModifierValue))
					{
						node.Modifier = newValue;
					}
				}

				LeaveContinueStatement(node);
			}
		}

		public virtual bool EnterContinueStatement(Milo.Ast.ContinueStatement node)
		{
			return true;
		}
		
		public virtual void LeaveContinueStatement(Milo.Ast.ContinueStatement node)
		{
		}

		public virtual void OnReturnStatement(Milo.Ast.ReturnStatement node)
		{	
			if (EnterReturnStatement(node))
			{
				StatementModifier currentModifierValue = node.Modifier;
				if (null != currentModifierValue)
				{			
					StatementModifier newValue = (StatementModifier)VisitNode(currentModifierValue);
					if (!object.ReferenceEquals(newValue, currentModifierValue))
					{
						node.Modifier = newValue;
					}
				}
				Expression currentExpressionValue = node.Expression;
				if (null != currentExpressionValue)
				{			
					Expression newValue = (Expression)VisitNode(currentExpressionValue);
					if (!object.ReferenceEquals(newValue, currentExpressionValue))
					{
						node.Expression = newValue;
					}
				}

				LeaveReturnStatement(node);
			}
		}

		public virtual bool EnterReturnStatement(Milo.Ast.ReturnStatement node)
		{
			return true;
		}
		
		public virtual void LeaveReturnStatement(Milo.Ast.ReturnStatement node)
		{
		}

		public virtual void OnYieldStatement(Milo.Ast.YieldStatement node)
		{	
			if (EnterYieldStatement(node))
			{
				StatementModifier currentModifierValue = node.Modifier;
				if (null != currentModifierValue)
				{			
					StatementModifier newValue = (StatementModifier)VisitNode(currentModifierValue);
					if (!object.ReferenceEquals(newValue, currentModifierValue))
					{
						node.Modifier = newValue;
					}
				}
				Expression currentExpressionValue = node.Expression;
				if (null != currentExpressionValue)
				{			
					Expression newValue = (Expression)VisitNode(currentExpressionValue);
					if (!object.ReferenceEquals(newValue, currentExpressionValue))
					{
						node.Expression = newValue;
					}
				}

				LeaveYieldStatement(node);
			}
		}

		public virtual bool EnterYieldStatement(Milo.Ast.YieldStatement node)
		{
			return true;
		}
		
		public virtual void LeaveYieldStatement(Milo.Ast.YieldStatement node)
		{
		}

		public virtual void OnRaiseStatement(Milo.Ast.RaiseStatement node)
		{	
			if (EnterRaiseStatement(node))
			{
				StatementModifier currentModifierValue = node.Modifier;
				if (null != currentModifierValue)
				{			
					StatementModifier newValue = (StatementModifier)VisitNode(currentModifierValue);
					if (!object.ReferenceEquals(newValue, currentModifierValue))
					{
						node.Modifier = newValue;
					}
				}
				Expression currentExceptionValue = node.Exception;
				if (null != currentExceptionValue)
				{			
					Expression newValue = (Expression)VisitNode(currentExceptionValue);
					if (!object.ReferenceEquals(newValue, currentExceptionValue))
					{
						node.Exception = newValue;
					}
				}

				LeaveRaiseStatement(node);
			}
		}

		public virtual bool EnterRaiseStatement(Milo.Ast.RaiseStatement node)
		{
			return true;
		}
		
		public virtual void LeaveRaiseStatement(Milo.Ast.RaiseStatement node)
		{
		}

		public virtual void OnUnpackStatement(Milo.Ast.UnpackStatement node)
		{	
			if (EnterUnpackStatement(node))
			{
				StatementModifier currentModifierValue = node.Modifier;
				if (null != currentModifierValue)
				{			
					StatementModifier newValue = (StatementModifier)VisitNode(currentModifierValue);
					if (!object.ReferenceEquals(newValue, currentModifierValue))
					{
						node.Modifier = newValue;
					}
				}
				Visit(node.Declarations);
				Expression currentExpressionValue = node.Expression;
				if (null != currentExpressionValue)
				{			
					Expression newValue = (Expression)VisitNode(currentExpressionValue);
					if (!object.ReferenceEquals(newValue, currentExpressionValue))
					{
						node.Expression = newValue;
					}
				}

				LeaveUnpackStatement(node);
			}
		}

		public virtual bool EnterUnpackStatement(Milo.Ast.UnpackStatement node)
		{
			return true;
		}
		
		public virtual void LeaveUnpackStatement(Milo.Ast.UnpackStatement node)
		{
		}

		public virtual void OnExpressionStatement(Milo.Ast.ExpressionStatement node)
		{	
			if (EnterExpressionStatement(node))
			{
				StatementModifier currentModifierValue = node.Modifier;
				if (null != currentModifierValue)
				{			
					StatementModifier newValue = (StatementModifier)VisitNode(currentModifierValue);
					if (!object.ReferenceEquals(newValue, currentModifierValue))
					{
						node.Modifier = newValue;
					}
				}
				Expression currentExpressionValue = node.Expression;
				if (null != currentExpressionValue)
				{			
					Expression newValue = (Expression)VisitNode(currentExpressionValue);
					if (!object.ReferenceEquals(newValue, currentExpressionValue))
					{
						node.Expression = newValue;
					}
				}

				LeaveExpressionStatement(node);
			}
		}

		public virtual bool EnterExpressionStatement(Milo.Ast.ExpressionStatement node)
		{
			return true;
		}
		
		public virtual void LeaveExpressionStatement(Milo.Ast.ExpressionStatement node)
		{
		}

		public virtual void OnOmittedExpression(Milo.Ast.OmittedExpression node)
		{	
		}

		public virtual void OnExpressionPair(Milo.Ast.ExpressionPair node)
		{	
			if (EnterExpressionPair(node))
			{
				Expression currentFirstValue = node.First;
				if (null != currentFirstValue)
				{			
					Expression newValue = (Expression)VisitNode(currentFirstValue);
					if (!object.ReferenceEquals(newValue, currentFirstValue))
					{
						node.First = newValue;
					}
				}
				Expression currentSecondValue = node.Second;
				if (null != currentSecondValue)
				{			
					Expression newValue = (Expression)VisitNode(currentSecondValue);
					if (!object.ReferenceEquals(newValue, currentSecondValue))
					{
						node.Second = newValue;
					}
				}

				LeaveExpressionPair(node);
			}
		}

		public virtual bool EnterExpressionPair(Milo.Ast.ExpressionPair node)
		{
			return true;
		}
		
		public virtual void LeaveExpressionPair(Milo.Ast.ExpressionPair node)
		{
		}

		public virtual void OnMethodInvocationExpression(Milo.Ast.MethodInvocationExpression node)
		{	
			if (EnterMethodInvocationExpression(node))
			{
				Expression currentTargetValue = node.Target;
				if (null != currentTargetValue)
				{			
					Expression newValue = (Expression)VisitNode(currentTargetValue);
					if (!object.ReferenceEquals(newValue, currentTargetValue))
					{
						node.Target = newValue;
					}
				}
				Visit(node.Arguments);
				Visit(node.NamedArguments);

				LeaveMethodInvocationExpression(node);
			}
		}

		public virtual bool EnterMethodInvocationExpression(Milo.Ast.MethodInvocationExpression node)
		{
			return true;
		}
		
		public virtual void LeaveMethodInvocationExpression(Milo.Ast.MethodInvocationExpression node)
		{
		}

		public virtual void OnUnaryExpression(Milo.Ast.UnaryExpression node)
		{	
			if (EnterUnaryExpression(node))
			{
				Expression currentOperandValue = node.Operand;
				if (null != currentOperandValue)
				{			
					Expression newValue = (Expression)VisitNode(currentOperandValue);
					if (!object.ReferenceEquals(newValue, currentOperandValue))
					{
						node.Operand = newValue;
					}
				}

				LeaveUnaryExpression(node);
			}
		}

		public virtual bool EnterUnaryExpression(Milo.Ast.UnaryExpression node)
		{
			return true;
		}
		
		public virtual void LeaveUnaryExpression(Milo.Ast.UnaryExpression node)
		{
		}

		public virtual void OnBinaryExpression(Milo.Ast.BinaryExpression node)
		{	
			if (EnterBinaryExpression(node))
			{
				Expression currentLeftValue = node.Left;
				if (null != currentLeftValue)
				{			
					Expression newValue = (Expression)VisitNode(currentLeftValue);
					if (!object.ReferenceEquals(newValue, currentLeftValue))
					{
						node.Left = newValue;
					}
				}
				Expression currentRightValue = node.Right;
				if (null != currentRightValue)
				{			
					Expression newValue = (Expression)VisitNode(currentRightValue);
					if (!object.ReferenceEquals(newValue, currentRightValue))
					{
						node.Right = newValue;
					}
				}

				LeaveBinaryExpression(node);
			}
		}

		public virtual bool EnterBinaryExpression(Milo.Ast.BinaryExpression node)
		{
			return true;
		}
		
		public virtual void LeaveBinaryExpression(Milo.Ast.BinaryExpression node)
		{
		}

		public virtual void OnConditionalExpression(Milo.Ast.ConditionalExpression node)
		{	
			if (EnterConditionalExpression(node))
			{
				Expression currentConditionValue = node.Condition;
				if (null != currentConditionValue)
				{			
					Expression newValue = (Expression)VisitNode(currentConditionValue);
					if (!object.ReferenceEquals(newValue, currentConditionValue))
					{
						node.Condition = newValue;
					}
				}
				Expression currentTrueValueValue = node.TrueValue;
				if (null != currentTrueValueValue)
				{			
					Expression newValue = (Expression)VisitNode(currentTrueValueValue);
					if (!object.ReferenceEquals(newValue, currentTrueValueValue))
					{
						node.TrueValue = newValue;
					}
				}
				Expression currentFalseValueValue = node.FalseValue;
				if (null != currentFalseValueValue)
				{			
					Expression newValue = (Expression)VisitNode(currentFalseValueValue);
					if (!object.ReferenceEquals(newValue, currentFalseValueValue))
					{
						node.FalseValue = newValue;
					}
				}

				LeaveConditionalExpression(node);
			}
		}

		public virtual bool EnterConditionalExpression(Milo.Ast.ConditionalExpression node)
		{
			return true;
		}
		
		public virtual void LeaveConditionalExpression(Milo.Ast.ConditionalExpression node)
		{
		}

		public virtual void OnReferenceExpression(Milo.Ast.ReferenceExpression node)
		{	
		}

		public virtual void OnMemberReferenceExpression(Milo.Ast.MemberReferenceExpression node)
		{	
			if (EnterMemberReferenceExpression(node))
			{
				Expression currentTargetValue = node.Target;
				if (null != currentTargetValue)
				{			
					Expression newValue = (Expression)VisitNode(currentTargetValue);
					if (!object.ReferenceEquals(newValue, currentTargetValue))
					{
						node.Target = newValue;
					}
				}

				LeaveMemberReferenceExpression(node);
			}
		}

		public virtual bool EnterMemberReferenceExpression(Milo.Ast.MemberReferenceExpression node)
		{
			return true;
		}
		
		public virtual void LeaveMemberReferenceExpression(Milo.Ast.MemberReferenceExpression node)
		{
		}

		public virtual void OnGenericReferenceExpression(Milo.Ast.GenericReferenceExpression node)
		{	
			if (EnterGenericReferenceExpression(node))
			{
				Expression currentTargetValue = node.Target;
				if (null != currentTargetValue)
				{			
					Expression newValue = (Expression)VisitNode(currentTargetValue);
					if (!object.ReferenceEquals(newValue, currentTargetValue))
					{
						node.Target = newValue;
					}
				}
				Visit(node.GenericArguments);

				LeaveGenericReferenceExpression(node);
			}
		}

		public virtual bool EnterGenericReferenceExpression(Milo.Ast.GenericReferenceExpression node)
		{
			return true;
		}
		
		public virtual void LeaveGenericReferenceExpression(Milo.Ast.GenericReferenceExpression node)
		{
		}

		public virtual void OnSpliceExpression(Milo.Ast.SpliceExpression node)
		{	
			if (EnterSpliceExpression(node))
			{
				Expression currentExpressionValue = node.Expression;
				if (null != currentExpressionValue)
				{			
					Expression newValue = (Expression)VisitNode(currentExpressionValue);
					if (!object.ReferenceEquals(newValue, currentExpressionValue))
					{
						node.Expression = newValue;
					}
				}

				LeaveSpliceExpression(node);
			}
		}

		public virtual bool EnterSpliceExpression(Milo.Ast.SpliceExpression node)
		{
			return true;
		}
		
		public virtual void LeaveSpliceExpression(Milo.Ast.SpliceExpression node)
		{
		}

		public virtual void OnCodeLiteralExpression(Milo.Ast.CodeLiteralExpression node)
		{	
		}

		public virtual void OnStringLiteralExpression(Milo.Ast.StringLiteralExpression node)
		{	
		}

		public virtual void OnCharLiteralExpression(Milo.Ast.CharLiteralExpression node)
		{	
		}

		public virtual void OnTimeSpanLiteralExpression(Milo.Ast.TimeSpanLiteralExpression node)
		{	
		}

		public virtual void OnIntegerLiteralExpression(Milo.Ast.IntegerLiteralExpression node)
		{	
		}

		public virtual void OnDoubleLiteralExpression(Milo.Ast.DoubleLiteralExpression node)
		{	
		}

		public virtual void OnNullLiteralExpression(Milo.Ast.NullLiteralExpression node)
		{	
		}

		public virtual void OnSelfLiteralExpression(Milo.Ast.SelfLiteralExpression node)
		{	
		}

		public virtual void OnSuperLiteralExpression(Milo.Ast.SuperLiteralExpression node)
		{	
		}

		public virtual void OnBoolLiteralExpression(Milo.Ast.BoolLiteralExpression node)
		{	
		}

		public virtual void OnRELiteralExpression(Milo.Ast.RELiteralExpression node)
		{	
		}

		public virtual void OnExpressionInterpolationExpression(Milo.Ast.ExpressionInterpolationExpression node)
		{	
			if (EnterExpressionInterpolationExpression(node))
			{
				Visit(node.Expressions);

				LeaveExpressionInterpolationExpression(node);
			}
		}

		public virtual bool EnterExpressionInterpolationExpression(Milo.Ast.ExpressionInterpolationExpression node)
		{
			return true;
		}
		
		public virtual void LeaveExpressionInterpolationExpression(Milo.Ast.ExpressionInterpolationExpression node)
		{
		}

		public virtual void OnHashLiteralExpression(Milo.Ast.HashLiteralExpression node)
		{	
			if (EnterHashLiteralExpression(node))
			{
				Visit(node.Items);

				LeaveHashLiteralExpression(node);
			}
		}

		public virtual bool EnterHashLiteralExpression(Milo.Ast.HashLiteralExpression node)
		{
			return true;
		}
		
		public virtual void LeaveHashLiteralExpression(Milo.Ast.HashLiteralExpression node)
		{
		}

		public virtual void OnListLiteralExpression(Milo.Ast.ListLiteralExpression node)
		{	
			if (EnterListLiteralExpression(node))
			{
				Visit(node.Items);

				LeaveListLiteralExpression(node);
			}
		}

		public virtual bool EnterListLiteralExpression(Milo.Ast.ListLiteralExpression node)
		{
			return true;
		}
		
		public virtual void LeaveListLiteralExpression(Milo.Ast.ListLiteralExpression node)
		{
		}

		public virtual void OnArrayLiteralExpression(Milo.Ast.ArrayLiteralExpression node)
		{	
			if (EnterArrayLiteralExpression(node))
			{
				Visit(node.Items);
				ArrayTypeReference currentTypeValue = node.Type;
				if (null != currentTypeValue)
				{			
					ArrayTypeReference newValue = (ArrayTypeReference)VisitNode(currentTypeValue);
					if (!object.ReferenceEquals(newValue, currentTypeValue))
					{
						node.Type = newValue;
					}
				}

				LeaveArrayLiteralExpression(node);
			}
		}

		public virtual bool EnterArrayLiteralExpression(Milo.Ast.ArrayLiteralExpression node)
		{
			return true;
		}
		
		public virtual void LeaveArrayLiteralExpression(Milo.Ast.ArrayLiteralExpression node)
		{
		}

		public virtual void OnGeneratorExpression(Milo.Ast.GeneratorExpression node)
		{	
			if (EnterGeneratorExpression(node))
			{
				Expression currentExpressionValue = node.Expression;
				if (null != currentExpressionValue)
				{			
					Expression newValue = (Expression)VisitNode(currentExpressionValue);
					if (!object.ReferenceEquals(newValue, currentExpressionValue))
					{
						node.Expression = newValue;
					}
				}
				Visit(node.Declarations);
				Expression currentIteratorValue = node.Iterator;
				if (null != currentIteratorValue)
				{			
					Expression newValue = (Expression)VisitNode(currentIteratorValue);
					if (!object.ReferenceEquals(newValue, currentIteratorValue))
					{
						node.Iterator = newValue;
					}
				}
				StatementModifier currentFilterValue = node.Filter;
				if (null != currentFilterValue)
				{			
					StatementModifier newValue = (StatementModifier)VisitNode(currentFilterValue);
					if (!object.ReferenceEquals(newValue, currentFilterValue))
					{
						node.Filter = newValue;
					}
				}

				LeaveGeneratorExpression(node);
			}
		}

		public virtual bool EnterGeneratorExpression(Milo.Ast.GeneratorExpression node)
		{
			return true;
		}
		
		public virtual void LeaveGeneratorExpression(Milo.Ast.GeneratorExpression node)
		{
		}

		public virtual void OnExtendedGeneratorExpression(Milo.Ast.ExtendedGeneratorExpression node)
		{	
			if (EnterExtendedGeneratorExpression(node))
			{
				Visit(node.Items);

				LeaveExtendedGeneratorExpression(node);
			}
		}

		public virtual bool EnterExtendedGeneratorExpression(Milo.Ast.ExtendedGeneratorExpression node)
		{
			return true;
		}
		
		public virtual void LeaveExtendedGeneratorExpression(Milo.Ast.ExtendedGeneratorExpression node)
		{
		}

		public virtual void OnSlice(Milo.Ast.Slice node)
		{	
			if (EnterSlice(node))
			{
				Expression currentBeginValue = node.Begin;
				if (null != currentBeginValue)
				{			
					Expression newValue = (Expression)VisitNode(currentBeginValue);
					if (!object.ReferenceEquals(newValue, currentBeginValue))
					{
						node.Begin = newValue;
					}
				}
				Expression currentEndValue = node.End;
				if (null != currentEndValue)
				{			
					Expression newValue = (Expression)VisitNode(currentEndValue);
					if (!object.ReferenceEquals(newValue, currentEndValue))
					{
						node.End = newValue;
					}
				}
				Expression currentStepValue = node.Step;
				if (null != currentStepValue)
				{			
					Expression newValue = (Expression)VisitNode(currentStepValue);
					if (!object.ReferenceEquals(newValue, currentStepValue))
					{
						node.Step = newValue;
					}
				}

				LeaveSlice(node);
			}
		}

		public virtual bool EnterSlice(Milo.Ast.Slice node)
		{
			return true;
		}
		
		public virtual void LeaveSlice(Milo.Ast.Slice node)
		{
		}

		public virtual void OnSlicingExpression(Milo.Ast.SlicingExpression node)
		{	
			if (EnterSlicingExpression(node))
			{
				Expression currentTargetValue = node.Target;
				if (null != currentTargetValue)
				{			
					Expression newValue = (Expression)VisitNode(currentTargetValue);
					if (!object.ReferenceEquals(newValue, currentTargetValue))
					{
						node.Target = newValue;
					}
				}
				Visit(node.Indices);

				LeaveSlicingExpression(node);
			}
		}

		public virtual bool EnterSlicingExpression(Milo.Ast.SlicingExpression node)
		{
			return true;
		}
		
		public virtual void LeaveSlicingExpression(Milo.Ast.SlicingExpression node)
		{
		}

		public virtual void OnTryCastExpression(Milo.Ast.TryCastExpression node)
		{	
			if (EnterTryCastExpression(node))
			{
				Expression currentTargetValue = node.Target;
				if (null != currentTargetValue)
				{			
					Expression newValue = (Expression)VisitNode(currentTargetValue);
					if (!object.ReferenceEquals(newValue, currentTargetValue))
					{
						node.Target = newValue;
					}
				}
				TypeReference currentTypeValue = node.Type;
				if (null != currentTypeValue)
				{			
					TypeReference newValue = (TypeReference)VisitNode(currentTypeValue);
					if (!object.ReferenceEquals(newValue, currentTypeValue))
					{
						node.Type = newValue;
					}
				}

				LeaveTryCastExpression(node);
			}
		}

		public virtual bool EnterTryCastExpression(Milo.Ast.TryCastExpression node)
		{
			return true;
		}
		
		public virtual void LeaveTryCastExpression(Milo.Ast.TryCastExpression node)
		{
		}

		public virtual void OnCastExpression(Milo.Ast.CastExpression node)
		{	
			if (EnterCastExpression(node))
			{
				Expression currentTargetValue = node.Target;
				if (null != currentTargetValue)
				{			
					Expression newValue = (Expression)VisitNode(currentTargetValue);
					if (!object.ReferenceEquals(newValue, currentTargetValue))
					{
						node.Target = newValue;
					}
				}
				TypeReference currentTypeValue = node.Type;
				if (null != currentTypeValue)
				{			
					TypeReference newValue = (TypeReference)VisitNode(currentTypeValue);
					if (!object.ReferenceEquals(newValue, currentTypeValue))
					{
						node.Type = newValue;
					}
				}

				LeaveCastExpression(node);
			}
		}

		public virtual bool EnterCastExpression(Milo.Ast.CastExpression node)
		{
			return true;
		}
		
		public virtual void LeaveCastExpression(Milo.Ast.CastExpression node)
		{
		}

		public virtual void OnTypeofExpression(Milo.Ast.TypeofExpression node)
		{	
			if (EnterTypeofExpression(node))
			{
				TypeReference currentTypeValue = node.Type;
				if (null != currentTypeValue)
				{			
					TypeReference newValue = (TypeReference)VisitNode(currentTypeValue);
					if (!object.ReferenceEquals(newValue, currentTypeValue))
					{
						node.Type = newValue;
					}
				}

				LeaveTypeofExpression(node);
			}
		}

		public virtual bool EnterTypeofExpression(Milo.Ast.TypeofExpression node)
		{
			return true;
		}
		
		public virtual void LeaveTypeofExpression(Milo.Ast.TypeofExpression node)
		{
		}

	}
}
